//////////////////////////////////////////
// Proxy generated class
//////////////////////////////////////////

package Phase2;

import Phase1.Command;
import Phase1.Client;
import Phase1.GlobalID;
import Phase1.ObjectDB;

import java.io.IOException;
import java.io.ObjectStreamException;
import java.util.Map;

public class NodeProxy
	extends Phase2.Node
	implements Comparable<Node>
{

	private static final long serialVersionUID = 1L;
	//private GlobalID globalID;

	public NodeProxy(GlobalID globalID, int id)
	{
		this.globalID = globalID;
		this.id = id;
	}

	@Override
	public int compareTo(Phase2.Node p0)
	{
		Command command = new Command(globalID, "compareTo", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Integer) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Integer) null;
	}

/*	public int compareTo(java.lang.Object p0)
	{
		Command command = new Command(globalID, "compareTo", 
								new Class[]{java.lang.Object.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Integer) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Integer) null;
	}*/

	@Override
	public java.lang.String toString()
	{
		Command command = new Command(globalID, "toString", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (java.lang.String) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (java.lang.String) null;
	}

/*	private Phase2.Node find(int p0, Phase2.Node p1)
	{
		Command command = new Command(globalID, "find", 
								new Class[]{int.class, Phase2.Node.class}, 
								new Object[]{new Integer(p0), p1}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}*/

	@Override
	public Phase2.Node getParent(boolean p0)
	{
		Command command = new Command(globalID, "getParent", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public Phase2.Node remove()
	{
		Command command = new Command(globalID, "remove", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public int getId(boolean p0)
	{
		return id;
	}

	@Override
	public Phase2.NodeState getState(boolean p0)
	{
		Command command = new Command(globalID, "getState", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.NodeState) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.NodeState) null;
	}

	@Override
	public void insert(Phase2.Node p0)
	{
		Command command = new Command(globalID, "insert", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}
	@Override
	public void performInsert(Phase2.Node p0)
	{
		Command command = new Command(globalID, "performInsert", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void setState(Phase2.NodeState p0)
	{
		Command command = new Command(globalID, "setState", 
								new Class[]{Phase2.NodeState.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void beingModified(boolean p0)
	{
		Command command = new Command(globalID, "beingModified", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public Phase1.GlobalID getGlobalID()
	{
		Command command = new Command(globalID, "getGlobalID", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Phase1.GlobalID) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase1.GlobalID) null;
	}

	@Override
	public Phase2.NodeList getUpPointers(boolean p0)
	{
		Command command = new Command(globalID, "getUpPointers", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.NodeList) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.NodeList) null;
	}

	@Override
	public void addUpPointers(Phase2.NodeList p0)
	{
		Command command = new Command(globalID, "addUpPointers", 
								new Class[]{Phase2.NodeList.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void setUpPointers(Phase2.NodeList p0)
	{
		Command command = new Command(globalID, "setUpPointers", 
								new Class[]{Phase2.NodeList.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void setUpPointer(Phase2.Node p0)
	{
		Command command = new Command(globalID, "setUpPointer", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public Phase2.NodeList getDownPointers(boolean p0)
	{
		Command command = new Command(globalID, "getDownPointers", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.NodeList) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.NodeList) null;
	}

	@Override
	public void addDownPointers(Phase2.NodeList p0)
	{
		Command command = new Command(globalID, "addDownPointers", 
								new Class[]{Phase2.NodeList.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void setDownPointers(Phase2.NodeList p0)
	{
		Command command = new Command(globalID, "setDownPointers", 
								new Class[]{Phase2.NodeList.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}
	@Override
	public void setDownPointer(Phase2.Node p0)
	{
		Command command = new Command(globalID, "setDownPointer", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public Phase2.NodeList getNeighbours(boolean p0)
	{
		Command command = new Command(globalID, "getNeighbours", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.NodeList) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		catch (NullPointerException e)
		{
			throw e;
		}

		return (Phase2.NodeList) null;
	}

	@Override
	public Phase2.Node getNeighbour(int p0, boolean p1)
	{
		Command command = new Command(globalID, "getNeighbour", 
								new Class[]{int.class, boolean.class}, 
								new Object[]{new Integer(p0), p1}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public void addNeighbours(Phase2.NodeList p0)
	{
		Command command = new Command(globalID, "addNeighbours", 
								new Class[]{Phase2.NodeList.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void setNeighbours(Phase2.NodeList p0)
	{
		Command command = new Command(globalID, "setNeighbours", 
								new Class[]{Phase2.NodeList.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void addNeighbour(Phase2.Node p0)
	{
		Command command = new Command(globalID, "addNeighbour", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public Phase2.Node getFold(boolean p0)
	{
		Command command = new Command(globalID, "getFold", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public void setFold(Phase2.Node p0)
	{
		Command command = new Command(globalID, "setFold", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public Phase2.Node getOldFold()
	{
		Command command = new Command(globalID, "getOldFold", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public void setOldFold(Phase2.Node p0)
	{
		Command command = new Command(globalID, "setOldFold", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void setId(int p0)
	{
		Command command = new Command(globalID, "setId", 
								new Class[]{int.class}, 
								new Object[]{new Integer(p0)}, false);

		try
		{
			Client.voidSendData(globalID, command);
			this.id = p0;
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public int getHeight(boolean p0)
	{
		Command command = new Command(globalID, "getHeight", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Integer) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Integer) null;
	}

	@Override
	public Phase2.Node getChild(boolean p0)
	{
		Command command = new Command(globalID, "getChild", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	protected Object readResolve() throws ObjectStreamException
	{
		ObjectDB database = ObjectDB.getDatabase();
		if(database.get(this.globalID) != null)
		{
			return database.get(this.globalID);
		}
		else
		{
			return this;
		}
	}

	@Override
	public Object writeReplace() throws ObjectStreamException
	{
		return this;
	}

	@Override
	public Phase2.NodeOrRange goRight(Phase2.Node p0, boolean p1)
	{
		Command command = new Command(globalID, "goRight", 
								new Class[]{Phase2.Node.class, boolean.class}, 
								new Object[]{p0, p1}, true);

		try
		{
			return (Phase2.NodeOrRange) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.NodeOrRange) null;
	}

	@Override
	public Phase2.Node getInsertionPoint()
	{
		Command command = new Command(globalID, "getInsertionPoint", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public void insertionFoldSetup(Phase2.Node p0, Phase2.Node p1)
	{
		Command command = new Command(globalID, "insertionFoldSetup", 
								new Class[]{Phase2.Node.class, Phase2.Node.class}, 
								new Object[]{p0, p1}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public java.lang.String printAllNode()
	{
		Command command = new Command(globalID, "printAllNode", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (java.lang.String) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (java.lang.String) null;
	}

	@Override
	public Phase2.Node removeLastNode()
	{
		Command command = new Command(globalID, "removeLastNode", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public Phase2.Node replaceNode(Phase2.Node p0)
	{
		Command command = new Command(globalID, "replaceNode", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public Phase2.Node getLastNode()
	{
		Command command = new Command(globalID, "getLastNode", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	@Override
	public void removeNeighbor(Phase2.Node p0)
	{
		Command command = new Command(globalID, "removeNeighbor", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void removeUp(Phase2.Node p0)
	{
		Command command = new Command(globalID, "removeUp", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void removeFold(Phase2.Node p0)
	{
		Command command = new Command(globalID, "removeFold", 
								new Class[]{Phase2.Node.class}, 
								new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public void renewState()
	{
		Command command = new Command(globalID, "renewState", 
								new Class[]{}, 
								new Object[]{}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

	}

	@Override
	public Phase2.Node giveMeChild(boolean p0)
	{
		Command command = new Command(globalID, "giveMeChild", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}

	/*public Node checkLock()
	{
		Command command = new Command(globalID, "checkLock", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Phase2.Node) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (Phase2.Node) null;
	}*/

	@Override
	public boolean getInsertionLock()
	{
		Command command = new Command(globalID, "getInsertionLock", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (java.lang.Boolean) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		
		return (java.lang.Boolean) null;
	}

	@Override
	public boolean acquireAccessPriviledge(boolean p0)
	{
		Command command = new Command(globalID, "acquireAccessPriviledge", 
								new Class[]{boolean.class}, 
								new Object[]{p0}, true);

		try
		{
			return (java.lang.Boolean) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		
		return (java.lang.Boolean) null;
	}

	@Override
	public void releaseAccessPriviledge()
	{
		Command command = new Command(globalID, "releaseAccessPriviledge", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
	} /*

	public boolean getLockState()
	{
		Command command = new Command(globalID, "getLockState", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (java.lang.Boolean) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}

		return (java.lang.Boolean) null;
	}*/

	@Override
	public Object getPayload(String p0)
	{
		Command command = new Command(globalID, "getPayload", 
								new Class[]{String.class}, 
								new Object[]{p0}, true);

		try
		{
			return Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		
		return null;
	}

	@Override
	public Object setPayload(String p0, Object p1)
	{
		Command command = new Command(globalID, "setPayload", 
								new Class[]{String.class, Object.class}, 
								new Object[]{p0, p1}, true);

		try
		{
			return Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		
		return null;
	}

	@Override
	public void setWholePayload(Map<String, Object> p0)
	{
		Command command = new Command(globalID, "setWholePayload", 
								new Class[]{Map.class}, 
								new Object[]{p0}, true);

		try
		{
			Client.voidSendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
	}

	@Override
	@SuppressWarnings("unchecked")
	public Map<String, Object> getWholePayload()
	{
		Command command = new Command(globalID, "getWholePayload", 
								new Class[]{}, 
								new Object[]{}, true);

		try
		{
			return (Map<String, Object>) Client.sendData(globalID, command);
		}

		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
		
		return null;
	}

	@Override
	public void printMessage(String p0)
	{
		Command command = new Command(globalID, "printMessage", 
				new Class[]{String.class}, 
				new Object[]{p0}, false);

		try
		{
			Client.voidSendData(globalID, command);
		}
		
		catch (IOException e)
		{
			e.printStackTrace();
		}
		catch (ClassNotFoundException e)
		{
			e.printStackTrace();
		}
	}
	
}
